import {ElMessageBox} from "element-plus";

let loadedScripts = []

/**
	 * 动态加载JS脚本
	 * @param {String} src - 脚本地址
	 * @param {String} id - 脚本唯一标识
	 * @param {Function} callback - 加载完成回调
	 * @returns {Promise} - 返回Promise对象
	 */
export function loadScript(src, id, callback = null) {
	return new Promise((resolve, reject) => {
		// 检查脚本是否已存在
		if (document.getElementById(id)) {
			resolve()
			return
		}

		const script = document.createElement('script')
		script.src = src
		script.id = id
		script.async = true
		
		// 保存脚本引用以便日后移除
		loadedScripts.push({ id, element: script })

		// 加载成功事件
		script.onload = () => {
			console.log(`脚本 ${id} 加载成功`)
			if (callback && typeof callback === 'function') {
				callback()
			}
			resolve(script)
		}

		// 加载失败事件
		script.onerror = (error) => {
			console.error(`脚本 ${id} 加载失败:`, error)
			reject(error)
		};

		document.head.appendChild(script);
	})
}

// 批量加载多个脚本（按顺序）
export async function loadScripts(scripts) {
	for (const script of scripts) {
		await this.loadScript(script.src, script.id, script.callback)
	}
}

// 移除所有加载的脚本
export function removeAllScripts() {
	loadedScripts.forEach(script => {
		const element = document.getElementById(script.id)
		if (element) {
			document.head.removeChild(element)
			console.log(`脚本 ${script.id} 已移除`)
		}
	})

	loadedScripts = []
}

/**
 * 筛选数据的公共函数
 * @param {Object[]} data 被筛选的数据
 */
export function useFilterData(data = []) {
    let dataCache = data;

    /**
     * 设置被筛选的数据
     * @param {Object[]} data 被筛选的数据
     */
    function setData(data = []) {
        dataCache = data;
    }

    /**
     * 筛选数据
     * @param {String} keyword  筛选的关键字
     * @param {String} key      数据的 key 值
     * @returns 
     */
    function filter(keyword, key) {
        keyword = keyword.trim();

        if (keyword && Array.isArray(dataCache)) {
            const reg = new RegExp(keyword, 'i');

            return dataCache.reduce((result, item) => {
                if (reg.test(item[key])) {
                    result.push(item);
                }
                return result;
            }, []);
        }

        return Array.isArray(dataCache) ? dataCache : [];
    }

    /**
     * 销毁筛选器
     */
    function destroy() {
        dataCache = null;
    }

    return {
        setData,
        filter,
        destroy
    };
}

/**
 * 生成 elTable 的 span-method 事件函数
 * @param {Number[]} mergeCellIndex 需要合并单元格的列 index
 */
export function getTableMergeColumnMethod(mergeCellIndex, custom) {
    let rowspan = 1;
    let mergeCells = false;
    const tableRowLastIndex = mergeCellIndex.at(-1);

    const tableSpanMethod = ({ row, column, columnIndex, rowIndex } = {}) => {
        if (typeof custom === 'function') {
            const result = custom({ row, column, columnIndex, rowIndex });

            if (result) {
                return result;
            }
        }

        // 如果没有需要合并的单元格，返回默认的跨度
        if (!mergeCellIndex.length) {
            return [1, 1];
        }

        // 如果当前单元格是行的第一个单元格，初始化 rowspan 和 mergeCells 状态
        if (columnIndex === 0) {
            if (rowspan == 1) {
                mergeCells = true;
                rowspan = row.rowspan;
            }
        }

        if (mergeCellIndex.includes(columnIndex)) {
            if (mergeCells) {
                // 如果当前单元格是需要合并的最后一个单元格，重置 mergeCells 状态
                if (columnIndex === tableRowLastIndex) {
                    mergeCells = false;
                }

                return [rowspan, 1];
            }

            // 如果当前单元格是需要合并的最后一个单元格，减少 rowspan 值
            if (columnIndex === tableRowLastIndex) {
                rowspan--;
            }

            return [0, 0];
        }
    };

    return tableSpanMethod;
}

/**
 * 节流函数
 */
export function throttle(func, limit) {
    let lastFunc = null;
    let lastRan = null;

    const throttled = function (...args) {
        if (lastRan === null || Date.now() - lastRan >= limit) {
            func.apply(this, args);
            lastRan = Date.now();
        } else {
            // 如果已经有定时器在运行，清除之前的定时器
            if (lastFunc) {
                clearTimeout(lastFunc);
            }

            lastFunc = setTimeout(() => {
                func.apply(this, args);
                lastRan = Date.now();
            }, limit - (Date.now() - (lastRan || 0)));
        }
    };

    throttled.cancel = () => {
        if (lastFunc) {
            clearTimeout(lastFunc);
            lastFunc = null;
        }
    };

    return throttled;
}

/**
 * 防抖函数
 */
export function debounce(func, wait = 300, immediate = false) {
    let timeout = null;

    const debounced = function (...args) {
        const later = () => {
            timeout = null;

            if (!callNow) func.apply(this, args);
        };

        const callNow = immediate && !timeout;

        if (timeout) {
            clearTimeout(timeout);
        }

        timeout = setTimeout(later, wait);

        if (callNow) func.apply(this, args);
    };

    debounced.cancel = () => {
        if (timeout) {
            clearTimeout(timeout);
            timeout = null;
        }
    };

    return debounced;
}

export function deleteConfirm(message="确定删除此项吗？") {
    return ElMessageBox.confirm(message,{type: "warning"})
}